package cn.hello

import scala.collection._
import scala.collection.mutable.{ArrayBuffer, ListBuffer}


/**
  * Created by lzd on 2018/8/15.
  */
object ArrayDemo {
  def main(args: Array[String]) {
    //初始化一个长度为 8 的定长数组，其所有元素均为 0
    val arr1 = new Array[Int](8)
    //直接打印定长数组，内容为数组的 hashcode 值
    println(arr1)
    //将数组转换成数组缓冲，就可以看到原数组中的内容了
    //toBuffer 会将数组转换长数组缓冲
    println(arr1.toBuffer)
    //注意：如果 new，相当于调用了数组的 apply 方法，直接为数组赋值
    //初始化一个长度为 1 的定长数组
    val arr2 = Array[Int](10)
    println(arr2.toBuffer)
    //定义一个长度为 3 的定长数组
    val arr3 = Array("hadoop", "storm", "spark")
    //使用()来访问元素
    println(arr3(2))
    //////////////////////////////////////////////////
    //变长数组（数组缓冲）
    //如果想使用数组缓冲，需要导入 import scala.collection.mutable.ArrayBuffer 包
    val ab = ArrayBuffer[Int]()
    //向数组缓冲的尾部追加一个元素
    //+=尾部追加元素
    ab += 1
    //追加多个元素
    ab += (2, 3, 4, 5)
    //追加一个数组++=
    ab ++= Array(6, 7)
    //追加一个数组缓冲
    ab ++= ArrayBuffer(8, 9)
    //打印数组缓冲 ab
    //在数组某个位置插入元素用 insert
    ab.insert(0, -1, 0)
    //删除数组某个位置的元素用 remove
    ab.remove(8, 2)
    println(ab)
  }
}

object forDemo {
  def main(args: Array[String]): Unit = {
    val arr = Array(2, 1, 6, 8, 3, 4, 7, 5)
    for (i <- arr)
      print(i + "\t")

    println()

    for (i <- (0 until arr.length).reverse) {
      print(arr(i) + "\t")
    }
    println()
    println(arr.max)
    println(arr.sum)
    println(arr.sorted.toBuffer)
  }
}

object yeildDemo {
  def main(args: Array[String]): Unit = {
    //定义一个数组
    val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
    println(arr.toBuffer)
    //将偶数取出乘以10后再生成一个新的数组
    val res = for (e <- arr if e % 2 == 0) yield e * 10
    println(res.toBuffer)
    val r = arr.filter(_ % 2 == 0).map(_ * 10)
    println(r.toBuffer)
  }
}

//哈希表这种数据结构叫做映射
object mapDemo {
  def main(args: Array[String]): Unit = {
    var mp1 = Map("hello" -> "world", "my" -> "name")
    println(mp1)

    var mp2 = Map(("hello", "world"), ("my", "name"))
    println(mp2)

    println(mp1.get("my"))
    println(mp1("hello"))
    //有就返回值，没有返回默认值
    println(mp1.getOrElse("hello", "default"))
    println(mp1.getOrElse("hello1", "default"))

    /**
      * 1:是否可以修改值
      * Mutable  可以修改map里面的值
      * Immutable 不可以修改里面的值
      * *
      * 2：是否可以追加元素
      * mutable var/val 都可以追加元素
      * imtable var 可以追加，val不可以追加
      */
  }
}

object tupleDemo {
  def main(args: Array[String]): Unit = {
    val t = ("hadoop", 3.14, 123456)
    println(t)

    val (a, b, c) = ("hadoop", 3.14, 123456)
    println(a + "\t" + b + "\t" + c)

    println(t._1 + "\t" + t._2 + "\t" + t._3)

    val arr = Array((1,2),(2,3))
    println(arr.toMap)
  }
}
//拉链操作
object zipDemo{
  def main(args: Array[String]): Unit = {
    val a = Array(1,2,3)
    println(a.toBuffer)
    val b = Array("a","b","c")
    println(b.toBuffer)

    val c = a.zip(b)
    println(c.toBuffer)
  }
}

//修改后，创建新的集合
object listDemo{
  def main(args: Array[String]): Unit = {
    //创建一个不可变集合
    val list1 = List(1,2,3)
    //将0插入到集合list1的前面生成一个新的list
    val list2 = 0 :: list1
    val list3 = list1.:: (0)
    val list4 = 0 +: list1
    val list5 = list1. +: (0)

    println("list2=" + list2)
    println("list3=" + list3)
    println("list4=" + list4)
    println("list5=" + list5)

    val list6 = list1 :+ 3;
    println(list6)

    val list0 = list1 ++ list2;
    println(list0)

    //将list0插入到list1前面生成一个新的集合
    val list8 = list0 ++: list1
    println("list8="+list8)

    //将list1插入到list0前面生成一个新的集合
    val list9 = list1 ++: list0
    println("list9="+list9)
  }
}

//修改，是对原集合的修改
object ListBufferDemo{
  def main(args: Array[String]): Unit = {
    //构建一个可变序列
    val list1 = ListBuffer[Int](1,2,3)
    //创建一个空的可变序列
    val list2 = new ListBuffer[Int]
    //向list2中追加元素，注意：没有生成新的集合
    list2 += 6
    list2.append(7)
    println("list2=" + list2)

    //将list2中的元素追加到list1中，注意：没有生成新的集合
    list1 ++= list2
    print("list1=" + list1)

    //将list1和list2合并成一个新的list集合，注意：生成新的集合
    val list3 = list1 ++ list2
    println("list3=" + list3)

    //将元素追加到list1后面生成一个新的集合
    val list4 = list1 :+ 9
    print("list4=" + list4)
  }
}

object setDemoIm{
  def main(args: Array[String]): Unit = {
    //创建一个空的set
    val set1 = new immutable.HashSet[Int]()
    println("set1=" + set1)
    //将元素和set合并生成一个新的set，原有set不变
    val set2 = set1 + 4
    println("set2=" + set2)
    //set中元素不能重复
    val set3 = set1 ++ Set(5,6,7)
    println("set3=" + set3)
    val set4 = Set(4,3,2) ++ set2
    println("set4=" + set4)
  }
}

object setDemoM{
  def main(args: Array[String]): Unit = {
    //创建一个可变的set
    val set1 = new mutable.HashSet[Int]()
    println("list1=" + set1)
    //向set1中添加元素
    set1 += 4
    //add等价于+=
    set1.add(5)
    set1 ++= Set(6,7,8)
    println("set1="+set1)
    //删除一个元素
    set1 -= 8
    set1.remove(7)
    println("set1=" + set1)
  }
}

